package org.springblade.modules.demo.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.Query;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import liquibase.pro.packaged.O;
import liquibase.pro.packaged.S;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.collections.map.HashedMap;
import org.springblade.common.cache.UserCache;
import org.springblade.core.secure.BladeUser;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.utils.DateUtil;
import org.springblade.modules.auth.utils.DateUtils;
import org.springblade.modules.auth.utils.otherUtils;
import org.springblade.modules.demo.entity.DtmExpCardStoreSum;
import org.springblade.modules.demo.entity.DtmExpDataSum;
import org.springblade.modules.demo.entity.DtmExpFileSum;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

@Slf4j
@Service
public class HomePageProcessingService {
	@Resource
	private  IDtmExpDataSumService dtmExpDataSumService;

	@Resource
	private IDtmExpCardStoreSumService dtmExpCardStoreSumService;

	@Resource
	private IDtmExpFileSumService dtmExpFileSumService;



//变量 通过静态 注入容器

	private  static String  tradeCountSum=-1+"";			//交易次数累加值
	private static String thisTradeCountSum="-1";  //本期交易次数累加值
	private static String lastTradeCountSum="-1";	//同期交易次数累加值
	private static String lastTradeCountSum2="-1";	//上一期交易次数累加值


	private static String  realTicketPriceSum=-1+"";			//实扣金额累加值
	private static String  thisRealTicketPriceSum="-1";	//本期实扣金额累加值
	private static String  lastRealTicketPriceSum="-1"; //同期实扣金额累加值
	private static String  lastRealTicketPriceSum2="-1"; //上一期实扣金额累加值

	private static String thisCardCountSum="-1";		//本期的票卡数累加和
	private static String lastCardCountSum="-1";		//同期票卡数累加和
	private static String lastCardCountSum2="-1";	//上一期票卡数累加值





	/********************************************************************************/



	/**
	 * 获取交易次数 同比 环比
	 * 参数1:0 查询前一天的   1 查询近7天的
	 *
	 *
	 * */
	public Map<String,Object> tradeCountMap(int status ){
		Map<String,String> map1=new HashedMap();
		Map<String,Object> map=new HashedMap();

		if (status==0)   //拿昨天的交易次数同比环比
		{
			tradeCountSum=Query("TRADE_COUNT","T_DTM_EXP_DATA_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
			map1=	yearOnYear("TRADE_COUNT","T_DTM_EXP_DATA_SUM",0);
			thisTradeCountSum	=map1.get("thisTradeCountSum");						//获取本期交易笔数累加和
			lastTradeCountSum=map1.get("lastTradeCountSum");						//获取同期的交易笔数累加和
			String 	yearOnYear=map1.get("TradeCountYearOnYear");					//获取交易笔数同比

	//		String 	ringRatio=	this.ringRatio("TRADE_COUNT");
			map1=ringRatio("TRADE_COUNT","T_DTM_EXP_DATA_SUM");
			lastTradeCountSum2=map1.get("lastTradeCountSum2");					   //获取上一期的交易笔数累加和
			String 	ringRatio= map1.get("TradeCountRingRatio");					   //获取的交易笔数的环比
			map.put("thisTradeCountSum",tradeCountSum);						//交易次数累加和
			map.put("TradeCountYearOnYear",yearOnYear);			//交易次数同比
			map.put("TradeCountRingRatio",ringRatio);			//交易次数环比
			log.info("检查：12");
			return map;
		}else if (status==1)	//拿近7天的交易次数的同比环比
		{
//			tradeCountSum= query4("TRADE_COUNT","T_DTM_EXP_DATA_SUM");
			String endDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
			String startDayDate = DateUtils.getDate("yyyy-MM-dd",-7*24,Calendar.HOUR_OF_DAY) ;
			tradeCountSum= Query("TRADE_COUNT","T_DTM_EXP_DATA_SUM",startDayDate,endDayDate,1);

			map1=	yearOnYear("TRADE_COUNT","T_DTM_EXP_DATA_SUM",status);			//获取当前7天 和去年通时间段7天的个字段的同比
			thisTradeCountSum	=map1.get("thisTradeCountSum");						//获取本期交易笔数累加和
			lastTradeCountSum=map1.get("lastTradeCountSum");						//获取同期的交易笔数累加和
			String 	yearOnYear=map1.get("TradeCountYearOnYear");					//获取交易笔数同比

			map1=ringRatio("TRADE_COUNT","T_DTM_EXP_DATA_SUM");
			lastTradeCountSum2=map1.get("lastTradeCountSum2");					   //获取上一期的交易笔数累加和
			String 	ringRatio= map1.get("TradeCountRingRatio");					   //获取的交易笔数的环比
			map.put("thisTradeCountSum1",tradeCountSum);						//近一周 交易次数累加和
			map.put("TradeCountYearOnYear1",yearOnYear);						//近一周 交易次数同比
			map.put("TradeCountRingRatio1",ringRatio);							//近一周 交易次数环比
			log.info("检查：12");
			return map;
		}

		return map;
	}


		/**
		 * 获取实扣金额 同比 环比
		 * 参数1:0 查询前一天的。  1 查询近7天的
		 *
		 * */
		public  Map<String,Object> realTicketPriceMap(int status){
			Map<String,String> map1;
			if (status==0){
				realTicketPriceSum=Query("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
				log.info("累计和realTicketPriceSum："+realTicketPriceSum +"  字段：REAL_TICKET_PRICE"+ " 表：T_DTM_EXP_DATA_SUM "+ "时间："+DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY));

				map1=	this.yearOnYear("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM",0);
				thisRealTicketPriceSum =map1.get("thisRealTicketPriceSum");		//获取本期实扣金额累加值
				lastRealTicketPriceSum=map1.get("lastRealTicketPriceSum");   	//获取同期实扣金额累加值
				String 	yearOnYear=map1.get("RealTicketPriceYearOnYear");		//获取实扣金额同比

	//		String 	ringRatio=	this.ringRatio("REAL_TICKET_PRICE");		//不止返回环比率了 还返回本期 上一期累计和
				map1=	this.ringRatio("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM");
				lastRealTicketPriceSum2=map1.get("lastRealTicketPriceSum2");   	//获取上一期的实扣金额累加值
				String ringRatio=map1.get("RealTicketPriceRingRatio");			//获取实扣金额环比

				Map<String,Object> map=new HashedMap();						//为撒要创建2个MAP 只要这个是给前端的
				map.put("thisRealTicketPriceSum",realTicketPriceSum);	//实扣金额累加值
				map.put("RealTicketPriceYearOnYear",yearOnYear);		//实扣金额同比
				map.put("RealTicketPriceRingRatio",ringRatio);			//实扣金额环比

				return map;
			}else //status==1 清算时间是范围了
			{
//				realTicketPriceSum= this.query4("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM");
				String endDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
				String startDayDate = DateUtils.getDate("yyyy-MM-dd",-7*24,Calendar.HOUR_OF_DAY) ;
				realTicketPriceSum=Query("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM",startDayDate,endDayDate,1);

					//		String 	yearOnYear=	this.yearOnYear("REAL_TICKET_PRICE");   //不止返回同比率了 还返回本期 同期累计和
				map1=	this.yearOnYear("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM",0);
				thisRealTicketPriceSum =map1.get("thisRealTicketPriceSum");		//获取本期实扣金额累加值
				lastRealTicketPriceSum=map1.get("lastRealTicketPriceSum");   	//获取同期实扣金额累加值
				String 	yearOnYear=map1.get("RealTicketPriceYearOnYear");		//获取实扣金额同比

				//		String 	ringRatio=	this.ringRatio("REAL_TICKET_PRICE");		//不止返回环比率了 还返回本期 上一期累计和
				map1=	this.ringRatio("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM");
				lastRealTicketPriceSum2=map1.get("lastRealTicketPriceSum2");   	//获取上一期的实扣金额累加值
				String ringRatio=map1.get("RealTicketPriceRingRatio");			//获取实扣金额环比

				Map<String,Object> map=new HashedMap();						//为撒要创建2个MAP 只要这个是给前端的
				map.put("thisRealTicketPriceSum1",realTicketPriceSum);	//近一周 实扣金额累加值
				map.put("RealTicketPriceYearOnYear1",yearOnYear);		//近一周 实扣金额同比
				map.put("RealTicketPriceRingRatio1",ringRatio);			//近一周 实扣金额环比
				return map;
			}
		}



		/**
		 * 获取票卡使用量  同比 环比
		 * 参数1:0 查询前一天的。  1 查询近7天的
		 *
		 *
		 * */
		public Map<String,Object> cardCountMap(int status){
			Map<String,String> map1=new HashedMap();
			if (status==0)
			{
				String sum=Query("CARD_COUNT","T_DTM_EXP_CARD_STORE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
				map1=this.yearOnYear("CARD_COUNT","T_DTM_EXP_CARD_STORE_SUM",0);
				thisCardCountSum=map1.get("thisCardCountSum");				//获取本期票卡累计数
				lastCardCountSum=map1.get("lastCardCountSum");				//获取同期票卡累计数
				String CardCountSumYearOnYear=map1.get("CardCountSumYearOnYear");	//获取票卡数同比
				//			String 	ringRatio=	this.ringRatio("CARD_COUNT");
				map1=	this.ringRatio("CARD_COUNT","T_DTM_EXP_CARD_STORE_SUM");
				log.info("测试2222："+map1);
				lastCardCountSum2=map1.get("lastCardCountSum2");						//获取上一期票卡数累计
				log.info("测试222："+lastCardCountSum2);

				String  CardCountRingRatio=map1.get("CardCountRingRatio");				//获取环比

				Map<String,Object> map=new HashedMap();
				map.put("thisCardCountSum",thisCardCountSum);							//卡码用户数量累计和
				map.put("CardCountSumYearOnYear",CardCountSumYearOnYear);				//卡码用户数量同比
				map.put("CardCountRingRatio",CardCountRingRatio);						//卡码用户数量环比
				return  map;
			}else //status==1
			{
//				int sum= this.query4("CARD_COUNT","T_DTM_EXP_CARD_STORE_SUM");
				String endDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
				String startDayDate = DateUtils.getDate("yyyy-MM-dd",-24-7*24,Calendar.HOUR_OF_DAY) ;
				String sum=Query("CARD_COUNT","T_DTM_EXP_CARD_STORE_SUM",startDayDate,endDayDate,1);
				map1=this.yearOnYear("CARD_COUNT","T_DTM_EXP_CARD_STORE_SUM",1);
				thisCardCountSum=map1.get("thisCardCountSum");				//获取本期票卡累计数
				lastCardCountSum=map1.get("lastCardCountSum");				//获取同期票卡累计数
				String CardCountSumYearOnYear=map1.get("CardCountSumYearOnYear");	//获取票卡数同比
				//			String 	ringRatio=	this.ringRatio("CARD_COUNT");
				map1=	this.ringRatio("CARD_COUNT","T_DTM_EXP_CARD_STORE_SUM");
				log.info("测试2222："+map1);
				lastCardCountSum2=map1.get("lastCardCountSum2");						//获取上一期票卡数累计
				log.info("测试222："+lastCardCountSum2);

				String  CardCountRingRatio=map1.get("CardCountRingRatio");				//获取环比

				Map<String,Object> map=new HashedMap();
				map.put("thisCardCountSum1",thisCardCountSum);							//近一周 卡码用户数量累计和
				map.put("CardCountSumYearOnYear1",CardCountSumYearOnYear);				//近一周 卡码用户数量同比
				map.put("CardCountRingRatio1",CardCountRingRatio);						//近一周 卡码用户数量环比
				return  map;
			}

		}


	/**
	 * 获取客单价   同比，环比
	 * 参数1:0 查询前一天的。  1 查询近7天的
	 *
	 * */
	public Map<String,Object> unitPriceMap(int status){
		if (status==0)
		{
			//客单价=销售就金额/成交顾客数 =》实际金额/交易次数
//			float  unitPrice= (float)realTicketPriceSum/tradeCountSum;
			float  unitPrice= (float)(Float.parseFloat(realTicketPriceSum))/(Float.parseFloat(tradeCountSum));
			log.info("客单价："+unitPrice,"  实际金额累加值："+realTicketPriceSum,"  实际交易次数累加值:"+tradeCountSum);
			//客单价同比： 本期客单价-同期客单价/同期客单价X100%
			//=> (本期客单价-(同期实际金额/同期交易次数))/(同期实际金额/同期交易次数) X100%
			float unitPriceyearOnYear= (unitPrice- (Float.parseFloat(lastRealTicketPriceSum)/Float.parseFloat(lastTradeCountSum)))/(Float.parseFloat(lastRealTicketPriceSum)/Float.parseFloat(lastTradeCountSum));
			log.info("客单价同比:"+unitPriceyearOnYear+"   同期实际金额累加值："+lastRealTicketPriceSum+"    同期交易次数累加值："+lastTradeCountSum);
			//客单价环比：本期客单价-上一次客单价/上一期的客单价X100%
			//=>本期客单价-(上一期的实际金额/上一期的交易次数)/(上一期的实际金额/上一期的交易次数)X100%
			float unitPriceRingRatio=(unitPrice-(Float.parseFloat(lastRealTicketPriceSum2)/Float.parseFloat(lastTradeCountSum2)))/(Float.parseFloat(lastRealTicketPriceSum2)/Float.parseFloat(lastTradeCountSum2));
			log.info("客单价环比:"+unitPriceRingRatio+"   上一期实际金额累加值："+lastRealTicketPriceSum2+"    上一期交易次数累加值："+lastTradeCountSum2);
			//TODO 如果上面的值不对可能存在又要去取的问题了
			Map<String,Object> map=new HashedMap();
			map.put("unitPrice",unitPrice);						//客单价
			map.put("unitPriceyearOnYear",unitPriceyearOnYear);//客单价同比
			map.put("unitPriceRingRatio",unitPriceRingRatio);  //客单价环比
			return map;
		}else{
			//客单价=销售就金额/成交顾客数 =》实际金额/交易次数
//			float  unitPrice= (float)realTicketPriceSum/tradeCountSum;
			float  unitPrice= (float)(Float.parseFloat(realTicketPriceSum))/(Float.parseFloat(tradeCountSum));
			log.info("客单价："+unitPrice,"  实际金额累加值："+realTicketPriceSum,"  实际交易次数累加值:"+tradeCountSum);
			//客单价同比： 本期客单价-同期客单价/同期客单价X100%
			//=> (本期客单价-(同期实际金额/同期交易次数))/(同期实际金额/同期交易次数) X100%
			float unitPriceyearOnYear= (unitPrice- (Float.parseFloat(lastRealTicketPriceSum)/Float.parseFloat(lastTradeCountSum)))/(Float.parseFloat(lastRealTicketPriceSum)/Float.parseFloat(lastTradeCountSum));
			log.info("客单价同比:"+unitPriceyearOnYear+"   同期实际金额累加值："+lastRealTicketPriceSum+"    同期交易次数累加值："+lastTradeCountSum);
			//客单价环比：本期客单价-上一次客单价/上一期的客单价X100%
			//=>本期客单价-(上一期的实际金额/上一期的交易次数)/(上一期的实际金额/上一期的交易次数)X100%
			float unitPriceRingRatio=(unitPrice-(Float.parseFloat(lastRealTicketPriceSum2)/Float.parseFloat(lastTradeCountSum2)))/(Float.parseFloat(lastRealTicketPriceSum2)/Float.parseFloat(lastTradeCountSum2));
			log.info("客单价环比:"+unitPriceRingRatio+"   上一期实际金额累加值："+lastRealTicketPriceSum2+"    上一期交易次数累加值："+lastTradeCountSum2);
			//TODO 如果上面的值不对可能存在又要去取的问题了
			Map<String,Object> map=new HashedMap();
			map.put("unitPrice1",unitPrice);						//客单价
			map.put("unitPriceyearOnYear1",unitPriceyearOnYear);//客单价同比
			map.put("unitPriceRingRatio1",unitPriceRingRatio);  //客单价环比
			return map;
		}

	}




	static Map<String,Map<String,String>> localretMap=new HashedMap();

	//多个map  防止数据被覆盖
	static Map<String,Map<String,String>>localretMap1=new HashedMap();
	static Map<String,Map<String,String>>localretMap2=new HashedMap();
	static Map<String,Map<String,String>>localretMap3=new HashedMap();
	static Map<String,Map<String,String>>localretMap4=new HashedMap();
	static Map<String,Map<String,String>>localretMap5=new HashedMap();
	static Map<String,Map<String,String>>localretMap6=new HashedMap();


	/**
	 *
	 * 获取近一周的消费数据   貌似有2个 一个笔数  一个金额  也就是说要求出 笔数 还要求出金额 还有他们的  同比 环比
	 *
	 * 参数1： 0 一周时间是指的完整的一周 比如本周没过完 所以只会获取到上周的完整时间。 1 获取到前7天的时间
	 *
	 * */
	public  Map<String,Map<String,String>> GetWeekData(int status){
		long StartTime = System.currentTimeMillis(); 	// 1、开始时间

		//获取一周的时间 写死就创建7个
		String[]  dateNumArray=new String[7];
		if (status==0)
		{
			DateUtils.getDate();
			log.info("0.11："+DateUtils.getDate("yyyy-MM-dd",0,Calendar.HOUR_OF_DAY));
			log.info("1："+DateUtils.getDate("yyyy-MM-dd",24,Calendar.HOUR_OF_DAY));

			log.info("1。5："+DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY));
			log.info("2："+DateUtils.getDate("yyyy-MM-dd",120,Calendar.HOUR_OF_DAY));
			//获取今天的时间和今天星期几
			  String date= DateUtils.getDate();
			  int weekNum=DateUtils.getDayOfWeek();
			log.info("21星期几："+weekNum);


			dateNumArray[weekNum-1+0]= DateUtils.getDate("yyyy-MM-dd",24*0-(7*24),Calendar.HOUR_OF_DAY);

			for	(int i=0;i<7;i++){
				//当前数组索引不为空
				if (dateNumArray[i]==null)
				{
					if (i<(weekNum-1)){
					//要获取的是近一周就是上一周的
						dateNumArray[i]= DateUtils.getDate("yyyy-MM-dd",-24*(weekNum-1-i)-(7*24),Calendar.HOUR_OF_DAY);
					}else if (i>(weekNum-1)&&i<7){
	//					dateNumArray[i]=DateUtils.getDate("yyyy-MM-dd",24*(i-(weekNum-1)),Calendar.HOUR_OF_DAY);
						dateNumArray[i]=DateUtils.getDate("yyyy-MM-dd",24*(i-(weekNum-1))-(7*24),Calendar.HOUR_OF_DAY);
					}
				}
			}
			for (int i=0;i<7;i++){
				log.info("检查array["+i+"]："+dateNumArray[i]);
			}
		}else //默认获取前7天
		{
			for (int i=0;i<7;i++){
				dateNumArray[i]=DateUtils.getDate("yyyy-MM-dd",-24*(7-i),Calendar.HOUR_OF_DAY);
				log.info("检查array1["+i+"]："+dateNumArray[i]);
			}
		}

		long endTime = System.currentTimeMillis(); 	// 2、结束时间
		System.out.println("耗时1:"+(endTime-StartTime)+"毫秒");

		long StartTime2 = System.currentTimeMillis(); 	// 1、开始时间
		//时间有了,开始查询对应数据库

		localretMap1=	query3("TRADE_COUNT","T_DTM_EXP_DATA_SUM",dateNumArray);			//获取服务商0001  交易笔数 也就是消费笔数  一段时间的
		long endTime2 = System.currentTimeMillis(); 	// 2、结束时间
		System.out.println("耗时2:"+(endTime2-StartTime2)+"毫秒");
		log.info("重点检查："+localretMap1);
		for (Map.Entry<String, Map<String, String>> outkey : localretMap1.entrySet())
		{
			log.info("重点检查key："+outkey.getKey()   +" value："+outkey.getValue());

		}

//		HashMap<String, List<Long>> failedMapSingle = Maps.newHashMap();
//		HashMap<String, List<Long>> failedMap = Maps.newHashMap();
//
//		failedMap.put("a", Lists.newArrayList(1L));
//		failedMapSingle.put("a", Lists.newArrayList(2L));
//
//		if (MapUtils.isNotEmpty(failedMapSingle)) {
//			failedMapSingle.forEach((k, v) -> failedMap.merge(k, v, (v1, v2) -> {
//				if (CollectionUtils.isNotEmpty(v1) && CollectionUtils.isNotEmpty(v2)) {
//					List<Long> li = Lists.newArrayList();
//					li.addAll(v1);
//					li.addAll(v2);
//					return li;
//				} else if (CollectionUtils.isNotEmpty(v1) && CollectionUtils.isEmpty(v2)) {
//					return v1;
//				} else if (CollectionUtils.isEmpty(v1) && CollectionUtils.isNotEmpty(v2)) {
//					return v2;
//				}
//				return v1;
//			}));
//		}






		long StartTime3 = System.currentTimeMillis(); 	// 1、开始时间
		//同比 环比 和状态
		localretMap2=yearOnYear1("TRADE_COUNT","T_DTM_EXP_DATA_SUM",dateNumArray);
		log.info("重点检查2："+localretMap2);
		long endTime3 = System.currentTimeMillis(); 	// 2、结束时间
		System.out.println("耗时3:"+(endTime3-StartTime3)+"毫秒");







		long StartTime4 = System.currentTimeMillis(); 	// 1、开始时间

		localretMap3=ringRatio1("TRADE_COUNT","T_DTM_EXP_DATA_SUM",dateNumArray);
		log.info("重点检查3："+localretMap3);
		long endTime4 = System.currentTimeMillis(); 	// 2、结束时间
		System.out.println("耗时4:"+(endTime4-StartTime4)+"毫秒");
		long StartTime5 = System.currentTimeMillis(); 	// 1、开始时间
		localretMap4=query3("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM",dateNumArray);			//获取服务商0001  实付金额 也就是消费笔数  一段时间的
		long endTime5 = System.currentTimeMillis(); 	// 2、结束时间
		System.out.println("耗时5:"+(endTime5-StartTime5)+"毫秒");
		log.info("重点检查4："+localretMap4);

		long StartTime6 = System.currentTimeMillis(); 	// 1、开始时间
		//同比 环比 和状态
		localretMap5=yearOnYear1("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM",dateNumArray);
		long endTime6 = System.currentTimeMillis(); 	// 2、结束时间
		System.out.println("耗时6:"+(endTime6-StartTime6)+"毫秒");
		log.info("重点检查5："+localretMap5);
		long StartTime7 = System.currentTimeMillis(); 	// 1、开始时间
		localretMap6=ringRatio1("REAL_TICKET_PRICE","T_DTM_EXP_DATA_SUM",dateNumArray);
		long endTime7 = System.currentTimeMillis(); 	// 2、结束时间
		System.out.println("耗时7:"+(endTime7-StartTime7)+"毫秒");
		log.info("重点检查6："+localretMap6);



		long StartTime8 = System.currentTimeMillis(); 	// 1、开始时间
		localretMap=MapValueAdd(localretMap1,localretMap2);
		log.info("检一下："+localretMap);
		localretMap=MapValueAdd(localretMap3,localretMap2);
		log.info("检一下2："+localretMap);
		localretMap=MapValueAdd(localretMap4,localretMap2);
		log.info("检一下3："+localretMap);
		localretMap=MapValueAdd(localretMap5,localretMap2);
		log.info("检一下4："+localretMap);
		localretMap=MapValueAdd(localretMap6,localretMap2);
		log.info("检一下5："+localretMap);



//		//每次前先清空
//		localretMap.clear();
//		for(int i=0;i<tempMap.length;i++)
//		{
//			for (String key : tempMap[i].keySet())
//			{	//打印localretMap的 key和value
//				log.info(i+"当前外map："+tempMap[i]);
//				log.info("localretMap"+(i+1)+"的key:"+key + "  value: " + tempMap[i].get(key));
//				//把打印localretMap的value  转成的Object 在转回 Map
//				Map<String,Object> map = JSONObject.parseObject(JSON.toJSONString(tempMap[i].get(key)));
//				//打印这个我想要的map的key和value
//				for (  String key1 :   map.keySet()){
//					Obj1.put(key1,map.get(key1).toString());
//					localretMap.put(key,Obj1);
//					log.info(i+"里面层:"+key1 + " : " + map.get(key1)+ " 对应的外层key："+key);
//				}
//				log.info(i+"检查一下里面的Map当前值："+Obj1+"对应的外层MAp当前key:"+key+"  在看下当前i对应的时间是"+dateNumArray[i]);
//			}
//			log.info(i+"检查一下2："+Obj1  +"在检查一下i:"+i+" 并检查一下外层时间"+dateNumArray[i]);
//
//		}
//		log.info("循环完的："+Obj1);
//		log.info("循环完的："+localretMap);


//		for (String key : localretMap.keySet())
//		{	//打印localretMap的 key和value
//			System.out.println("最外层key:"+key + "  value: " + localretMap.get(key));
//			//把打印localretMap的value  转成的Object 在转回 Map
//			Map<String,Object> map = JSONObject.parseObject(JSON.toJSONString(localretMap.get(key)));
//			//打印这个我想要的map的key和value
//			for (  String key1 :   map.keySet()){
//				System.out.println("里面层:"+key1 + " : " + map.get(key1));
//			}
//		}
		long endTime8 = System.currentTimeMillis(); 	// 2、结束时间
		System.out.println("耗时8:"+(endTime8-StartTime8)+"毫秒");
		//前后端字段对应处理
//		前后端字段对应：
//		TRADE_COUNT  -》count
//		TradeCountYearOnYear  -> yearContrast
//		TradeCountYearTrend  ->  yearTrend
//		TradeCountRingRatio ->  monthContrast
//		TradeCountMonthContrastTrend -> monthTrend

		//返回前 先跟他字段对应

		//存返回值
		return  localretMap;
	}


	/**
	 * 获取上传的原始数据
	 *
	 *
	 * */
	public  Map<String,String>  GetUploadedRawData()
	{

		long StartTime = System.currentTimeMillis(); 	// 1、开始时间

		//后期优化一下 其实可以变成一次SQL 查询 这变成了6次 select

		//服务商和日期和定位表的字段是写死的 这个后期要改
		//上传原始数据 ：笔数
		String SUM=Query("FILE_RECORD_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);

		log.info("校验数据"+SUM);
		//上传原始数据 ：金额
		String SUM1 =Query("FILE_RECORD_TAL_AMT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("校验数据1"+SUM1);

		//上传原始数据 ：有效笔数
		String SUM2  =Query("VALID_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("校验数据2"+SUM2);
		//上传原始数据 ：有效金额
		String SUM3 =Query("VALID_DATA_TAL_AMT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("校验数据3"+SUM3);

		//上传原始数据 ：挂起笔数
		String SUM4=Query("UNCRT_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("校验数据4"+SUM4);
		//上传原始数据 ：挂起金额
		String SUM5 =Query("UNCRT_DATA_TAL_AMT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("校验数据5"+SUM5);

		long endTime = System.currentTimeMillis(); 	// 2、结束时间
		float time=   (endTime-StartTime)/1000;		//秒数
		log.info("GetUploadedRawData耗时："+time+ "  毫秒数:"+(endTime-StartTime));

		//拿到了开始拼接
		Map<String,String>map=new HashedMap();
		map.put("OriginalNumber",SUM+"");
		map.put("OriginalMoney",SUM1+"");

		map.put("EffectiveNumber",SUM2+"");
		map.put("EffectiveMoney",SUM3+"");

		map.put("HangNumber",SUM4+"");
		map.put("HangMoney",SUM5+"");

		return  map;
	}



	/**
	 * 昨日消费数据处理情况 这个其实不用写 因为需要的参数 在上面的函数都给出来了  前端应该能自己去获取
	 *
	 * 拆出来 后期也好分开 就是可能会多查一下  有性能问题了在考虑
	 *
	 * */
	public Map<String,String> GetYesterdayDataProcessing(){
		//目前我们查询的都是指定的09-02这个时间的  其实接口最新的只能查到昨天的
		//所以这里就直接拿上面查到的用,上面的可能以后的数据会改  这里就要单独写了
//		SUM  总笔数
//		SUM2 有效笔数
//		SUM4 挂起笔数

		//上传原始数据 ：笔数
		String SUM=Query("FILE_RECORD_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("上传原始数据 笔数:"+SUM);
		//上传原始数据 ：有效笔数
		String SUM2=Query("VALID_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("上传原始数据 有效笔数:"+SUM2);

		//上传原始数据 ：挂起笔数
		String SUM4=Query("UNCRT_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("上传原始数据 挂起笔数:"+SUM4);
		//拿到了开始拼接
		Map<String,String>map=new HashedMap();
		map.put("OriginalNumber",SUM+"");		//原始笔数
		map.put("EffectiveNumber",SUM2+"");     //有效笔数
		map.put("HangNumber",SUM4+"");          //挂起笔数
		return map;
	}

	/**
	 *其中：挂起数据分布
	 *
	 *
	 * */
	public Map<String,String> GetPendingDataDistribution(){

		/**其中：挂起数据分布 */
		// 拿挂起笔数做总 这个要给
		//TAC异常笔数
		String SUM6=Query("TAC_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("TAC异常笔数:"+SUM6);
		//黑名单笔数
		String SUM7=Query("BLACK_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("黑名单笔数:"+SUM7);
		//其他异常笔数   这个好多 =交易类型错误笔数+与历史记录重复笔数+文件内记录重复笔数+联机充值无效笔数+SAM卡不详笔数  +其它笔数

		//交易类型错误笔数
		String SUM8=Query("WTT_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("交易类型错误笔数:"+SUM8);
		//与历史记录重复笔数
		String SUM9=Query("DWH_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("与历史记录重复笔数:"+SUM9);
		//文件内记录重复笔数
		String SUM10=Query("DIF_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("文件内记录重复笔数:"+SUM10);
		//联机充值无效笔数
		String SUM11=Query("IOR_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("联机充值无效笔数:"+SUM11);
		//SAM卡不详笔数
		String SUM12=Query("SAM_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("SAM卡不详笔数:"+SUM12);
		//其他笔数
		String SUM13=Query("OTHER_DATA_TAL_CNT","T_DTM_EXP_FILE_SUM",DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY),"",0);
		log.info("其他笔数:"+SUM13);

		//拿到了开始拼接
		Map<String,String>map=new HashedMap();
		map.put("total",(SUM6+SUM7+SUM8+SUM9+SUM10+SUM11+SUM12+SUM13)+"");//总共
		map.put("TACNum",SUM6+"");										  //TAC异常数
		map.put("BlacklistNum",SUM7+"");								  //黑名单异常数
		map.put("OtherNum",(SUM8+SUM9+SUM10+SUM11+SUM12+SUM13)+"");	 	  //其他异常数
		return map;
	}


	/**
	 * 废弃了
	 *
	 * 参数1：查询字段
	 * 参数2：查询表名
	 *返回传参 查询到的总和 其他过滤条件都是 服务商是0001, 清算时间是 2021-09-02(测试数据就这日期的)   			//TRADE_COUNT 总交易次数
	 * SELECT sum(TRADE_COUNT) as sumAll FROM T_DTM_EXP_DATA_SUM
	 *
	 *
	 * SELECT sum(TRADE_COUNT) as sumAll FROM T_DTM_EXP_DATA_SUM  WHERE LIQ_CODE='0001' and LIQ_DATE= '2021-09-02'
	 *
	 * */
	public  String query1(String str,String TableName){
		float a=-1;
		if (TableName=="T_DTM_EXP_DATA_SUM"/*str=="REAL_TICKET_PRICE"||str=="TRADE_COUNT"*/) 	//查询消费数据日统计表T_DTM_EXP_FILE_SUM的数据
		{

			QueryWrapper<DtmExpDataSum> queryWrapper=new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data="sum("+ str + ") as sumAll";
			//数据求和
			queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			//TODO
			BladeUser bladeUser= AuthUtil.getUser();
			log.info("测试响应接口角色信息："+bladeUser);
			AuthUtil.getUserId();
			log.info("测试响应接口角色信息1："+AuthUtil.getUserId());
			UserCache.getUser(AuthUtil.getUserId());
			log.info("测试响应接口角色信息2："+UserCache.getUser(AuthUtil.getUserId()));
//		SysCache.getRoleAliases		//角色相关的
//		sysClient.getRoleAliases
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			//清算日期是 2021-09-02  获取前一天的时间
			String toDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
			log.info("测试响应接口toDayDate："+toDayDate/*"2021-09-02"*/);
			queryWrapper.eq(/*"liqDate"*/"LIQ_DATE",/*2021-09-02*/toDayDate);
			log.info("测试响应接口1.0：");
			Map<String,Object> 	map=dtmExpDataSumService.getMap(queryWrapper);

			log.info("测试响应接口1.1"+map);

			try{
				a=	Float.parseFloat(map.get("SUMALL").toString());
			}catch (Exception e){
				log.info("异常处理逻辑3");
				//a如果获取的是null
				a=-9999;
				return a+"";	//直接返回
			}
			return  a+"";
		}else if(/*str=="CARD_COUNT"*/TableName=="T_DTM_EXP_CARD_STORE_SUM")   //查询票卡使用商户统计表T_DTM_EXP_CARD_STORE_SUM的数据
		{
			QueryWrapper<DtmExpCardStoreSum> queryWrapper = new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data = "sum(" + str + ") as sumAll";
			//数据求和
			queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			//TODO
			BladeUser bladeUser = AuthUtil.getUser();
			log.info("测试响应接口角色信息：" + bladeUser);
			AuthUtil.getUserId();
			log.info("测试响应接口角色信息1：" + AuthUtil.getUserId());
			UserCache.getUser(AuthUtil.getUserId());
			log.info("测试响应接口角色信息2：" + UserCache.getUser(AuthUtil.getUserId()));
//		SysCache.getRoleAliases		//角色相关的  目前这个都写死了 全是0001
//		sysClient.getRoleAliases
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE", "268");
			//清算日期是 2021-09-02  实际这里是服务器的当天时间
			String toDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
			log.info("测试响应接口toDayDate：" + toDayDate);
			queryWrapper.eq(/*"liqDate"*/"LIQ_DATE",/*"2021-09-02"*/toDayDate);
			log.info("测试响应接口1：");
			Map<String, Object> map = dtmExpCardStoreSumService.getMap(queryWrapper);
			log.info("测试响应接口1.2" + map);
			try {
				a = Integer.parseInt(map.get("SUMALL").toString());

			} catch (Exception e) {
				log.info("异常处理逻辑4");
				//a如果获取的是null
				a = -9999;
				return a+"";    //直接返回

			}
			return a+"";
		}else if ( /*str=="VALID_DATA_TAL_CNT"*/TableName=="T_DTM_EXP_FILE_SUM")		//查询文件清算结果统计表T_DTM_EXP_FILE_SUM里面的数据
		{
			QueryWrapper<DtmExpFileSum> queryWrapper = new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data = "sum(" + str + ") as sumAll";
			//数据求和
			queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE", "268");
			String toDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
			log.info("测试响应接口toDayDate：" + toDayDate);
			queryWrapper.eq(/*"liqDate"*/"LIQ_DATE",/*"2021-09-02"*/toDayDate);
			log.info("测试响应接口13：");
			//SELECT sum(VALID_DATA_TAL_CNT) as sumAll FROM T_DTM_EXP_FILE_SUM WHERE  LIQ_CODE='0001'   AND LIQ_DATE='2021-09-02'
			Map<String, Object> map = dtmExpFileSumService.getMap(queryWrapper);
			log.info("测试响应接口14" + map);
			try {
				a = Integer.parseInt(map.get("SUMALL").toString());

			} catch (Exception e) {
				log.info("异常处理逻辑8");
				//a如果获取的是null
				a = -9999;
				return a+"";    //直接返回
			}
			return a+"";
		}
		return  a+"";
	}

	/**
	 * 查询指定字段的累计和
	 * 参数1:表里面的指定字段
	 * 参数2: 查询的清算时间
	 * 参数3：只有当参数4为1的时候 该参数生效 是范围的结尾时间
	 * 参数4： status=0 表示清算时间字段具体指定。  =1 表示清算时间是一个范围
	 * return:返回指定字段的 指定时间的交易次数累计和
	 *
	 * */
	public  String query2(String data,String date,String dateend,int status){
		DtmExpDataSum dtmExpDataSum=new DtmExpDataSum();
		if (data!="CARD_COUNT")
		{
			QueryWrapper<DtmExpDataSum> queryWrapper=new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			//数据求和
			String datatemp="sum("+ data /*"TRADE_COUNT"*/  +") as sumAll";
			queryWrapper.select(datatemp);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			//清算日期是 2021-09-02  实际这里是服务器的当天时间
			if (status==0){
				queryWrapper.eq("LIQ_DATE",date);

			}else //status==1
			{
				//比较2个时间的大小
				if (DateUtils.DateCompareSize(date,dateend)>0){
					queryWrapper.between("LIQ_DATE",dateend,date);
				}else {
					queryWrapper.between("LIQ_DATE",date,dateend);
				}

			}
			log.info("quety2开始调用sql查询接口查询字段为"+data);
			Map<String,Object>	map=dtmExpDataSumService.getMap(queryWrapper);
			//查询过滤后的值为null   比如查询对比的某个日期的数据 在数据库不存在
			if (map==null)
			{
				log.info("quety2查询结束 当前Map"+map+"值为Null");
				return  -1+"";
			}
			float a=-1;
			try{
				a=	Float.parseFloat(map.get("SUMALL").toString());
				if (status==0){
					log.info("quety2"+"成功获取当前时间:"+date+",指定服务商"+"268"+" 表字段"+data+" 累计和:"+a);
				}else{ //status==1
					log.info("quety2"+"成功获取当前时间范围为"+date+"到"+dateend+",指定服务商"+"268"+" 表字段"+data+" 累计和:"+a);
				}
			}catch (Exception e){
				log.info("异常处理逻辑5");
				if (status==0){
					log.info("quety2"+"查询失败获取当前时间:"+date+",指定服务商"+"268"+" 表字段"+data+" 累计和:"+a);
				}else{ //status==1
					log.info("quety2"+"查询失败获取当前时间"+date+"到"+dateend+",指定服务商"+"268"+" 表字段"+data+" 累计和:"+a);
				}
				//a如果获取的是null
				a=-9999;
//					e.printStackTrace();
			}
			return  a+"";
		}else 	//因为目前的数据是从2个表出来的 所以要判断一下字段是归类哪个表
		{
			QueryWrapper<DtmExpCardStoreSum> queryWrapper=new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			//数据求和
			String datatemp="sum("+ data /*"TRADE_COUNT"*/  +") as sumAll";
			queryWrapper.select(datatemp);
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			queryWrapper.eq("LIQ_DATE",date);
			log.info("测试响应接口0.2：");
			Map<String,Object> map=dtmExpCardStoreSumService.getMap(queryWrapper);
			log.info("测试响应接口2"+map);
			//查询过滤后的值为null   比如查询对比的某个日期的数据 在数据库不存在
			if (map==null)
			{
				log.info("测试响应接口2.1："+map);
				return  -1+"";
			}
			float a=-1;
			try{
				a=	Float.parseFloat(map.get("SUMALL").toString());
			}catch (Exception e){
				log.info("异常处理逻辑6");
				//a如果获取的是null
				a=-9999;
				return a+"";	//直接返回
			}
			return  a+"";
		}
	}





	/**
	 *  暂时这个函数只查T_DTM_EXP_DATA_SUM数据
	 *  参数1 查询到的字段
	 *  参数2 查询的表名
	 *  参数3 需要查询一段时间的数据的时间数组
	 *
	 *  返回： 查询字段的 指定服务商0001  传入参数2时间的   MAP数组  key: 清算时间或者说交易时间   value:一个Objcet 里面也是一个map 然后放了很多的值 同比环比 交易数量 啥的
	 * SELECT sum(TRADE_COUNT) as sumAll FROM T_DTM_EXP_DATA_SUM  WHERE LIQ_CODE='0001' and LIQ_DATE= '2021-09-02'
	 *
	 * */
	public  Map<String,Map<String,String>> query3(String Tablestr,String TableName,String[] WeekDate){
		Map<String,Map<String,String>> localmap=new HashedMap();
		if (TableName=="T_DTM_EXP_DATA_SUM")
		{
			log.info("开始查询表T_DTM_EXP_DATA_SUM数据");
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data="sum("+ Tablestr + ") as sumAll";
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			BladeUser bladeUser= AuthUtil.getUser();
			log.info("测试响应接口角色信息："+bladeUser);
			AuthUtil.getUserId();
			log.info("测试响应接口角色信息1："+AuthUtil.getUserId());
			UserCache.getUser(AuthUtil.getUserId());
			log.info("测试响应接口角色信息2："+UserCache.getUser(AuthUtil.getUserId()));
			float a=-1;

			//一周批量查询
			log.info("T_DTM_EXP_DATA_SUM 开始一周测试数据批量查询");
			for (int i=0;i<WeekDate.length;i++){
				Map<String,String> obj2=new HashedMap();
				QueryWrapper<DtmExpDataSum> queryWrapper=new QueryWrapper<>();
				//数据求和
				queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
				//指定服务商
				queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
				//指定时间
				queryWrapper.eq(/*"liqDate"*/"LIQ_DATE",WeekDate[i]);
				//获取指定数据
				Map<String,Object> map=dtmExpDataSumService.getMap(queryWrapper);
				try{
					a=	Float.parseFloat(map.get("SUMALL").toString());
					log.info(i+"成功获取当前时间"+WeekDate[i]+",指定服务商"+"268"+"表字段"+Tablestr+" 累计和:"+a);
				}catch (Exception e){
					//还不能这么处理  我特么要Obj转map的  但是又不想这崩  写一个假数据
					a=-9999;
					log.info(i+"失败获取当前时间"+WeekDate[i]+",指定服务商"+"268"+"表字段"+Tablestr+" 累计和:"+a);
					log.info("异常处理逻辑1");
				}
				log.info(i+"开始封装格式");
				log.info(i+"开始往2级map："+"  放入 key表字段"+Tablestr+"    累计和value:"+a);
//				Obj1.put(Tablestr,a+"");			//交易次数的总和  字符不对应前端
				obj2.put(Tablestr,a+"");
				log.info(i+"开始往1级map："+localmap+"  放入当前时间 key："+WeekDate[i]+"    value："+obj2);
//				localretMap.put(WeekDate[i],Obj1);
				localmap.put(WeekDate[i],obj2);
				log.info(i+"结束封装格式");
				a=-1;	//每次
			}
			return localmap;
		}
		else	//T_DTM_EXP_DATA_SUM    //警告 这个没有改造  直接传的null 后期有时间这里改下
		{
			log.info("警告开始查询T_DTM_EXP_DATA_SUM表");
			QueryWrapper<DtmExpCardStoreSum> queryWrapper=new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data="sum("+ Tablestr + ") as sumAll";
			//数据求和
			queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			//清算日期是 2021-09-02  实际这里是服务器的当天时间
			String toDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
			log.info("测试响应接口toDayDate："+toDayDate);
			queryWrapper.eq(/*"liqDate"*/"LIQ_DATE",/*"2021-09-02"*/toDayDate);
			log.info("测试响应接口0.3：");
			Map<String,Object> 	map=dtmExpCardStoreSumService.getMap(queryWrapper);
			log.info("测试响应接口2"+map);
			float a=-1;
			try{
				a=	Float.parseFloat(map.get("SUMALL").toString());
			}catch (Exception e){
				log.info("异常处理逻辑2");
//					e.printStackTrace();
			}
			return null;
		}

	}




	/**
	 * 临时接口,后期有空就优化    根据query1 变更 查询的是清算时间 从当前机器的昨天开始 前7天的
	 * 参数1：查询字段
	 * 参数2：查询表名
	 *返回传参 查询到的总和 其他过滤条件都是 服务商是0001, 清算时间是 2021-09-02(测试数据就这日期的)   			//TRADE_COUNT 总交易次数
	 * SELECT sum(TRADE_COUNT) as sumAll FROM T_DTM_EXP_DATA_SUM
	 *

	 * */
	public  String query4(String str,String TableName){
		float a=-1;
		if (TableName=="T_DTM_EXP_DATA_SUM"/*str=="REAL_TICKET_PRICE"||str=="TRADE_COUNT"*/) 	//查询消费数据日统计表T_DTM_EXP_FILE_SUM的数据
		{

			QueryWrapper<DtmExpDataSum> queryWrapper=new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data="sum("+ str + ") as sumAll";
			//数据求和
			queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			//TODO
			BladeUser bladeUser= AuthUtil.getUser();
			log.info("测试响应接口角色信息："+bladeUser);
			AuthUtil.getUserId();
			log.info("测试响应接口角色信息1："+AuthUtil.getUserId());
			UserCache.getUser(AuthUtil.getUserId());
			log.info("测试响应接口角色信息2："+UserCache.getUser(AuthUtil.getUserId()));
//		SysCache.getRoleAliases		//角色相关的
//		sysClient.getRoleAliases
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			//清算日期是 2021-09-02  获取前一天的时间
			String endDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;

			String startDayDate = DateUtils.getDate("yyyy-MM-dd",-7*24,Calendar.HOUR_OF_DAY) ;

			log.info("测试响应接口startDayDate："+startDayDate+"   endDayDate:"+endDayDate);
			//比较2个时间的大小
			if (DateUtils.DateCompareSize(startDayDate,endDayDate)>0){
				queryWrapper.between("LIQ_DATE",endDayDate,startDayDate);
			}else {
				queryWrapper.between("LIQ_DATE",startDayDate,endDayDate);
			}
			log.info("测试响应接口1.0：");
			Map<String,Object> 	map=dtmExpDataSumService.getMap(queryWrapper);
			log.info("测试响应接口1.1"+map);
			try{
				a=	Float.parseFloat(map.get("SUMALL").toString());
			}catch (Exception e){
				log.info("异常处理逻辑3");
				//a如果获取的是null
				a=-9999;
				return a+"";	//直接返回
			}
			return  a+"";
		}else if(/*str=="CARD_COUNT"*/TableName=="T_DTM_EXP_CARD_STORE_SUM")   //查询票卡使用商户统计表T_DTM_EXP_CARD_STORE_SUM的数据
		{
			QueryWrapper<DtmExpCardStoreSum> queryWrapper = new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data = "sum(" + str + ") as sumAll";
			//数据求和
			queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			//TODO
			BladeUser bladeUser = AuthUtil.getUser();
			log.info("测试响应接口角色信息：" + bladeUser);
			AuthUtil.getUserId();
			log.info("测试响应接口角色信息1：" + AuthUtil.getUserId());
			UserCache.getUser(AuthUtil.getUserId());
			log.info("测试响应接口角色信息2：" + UserCache.getUser(AuthUtil.getUserId()));
//		SysCache.getRoleAliases		//角色相关的  目前这个都写死了 全是0001
//		sysClient.getRoleAliases
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE", "268");


			//清算日期是 2021-09-02  获取前一天的时间
			String endDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
			String startDayDate = DateUtils.getDate("yyyy-MM-dd",-24-7*24,Calendar.HOUR_OF_DAY) ;
			log.info("测试响应接口startDayDate："+startDayDate+"   endDayDate:"+endDayDate);
			//比较2个时间的大小
			if (DateUtils.DateCompareSize(startDayDate,endDayDate)>0){
				queryWrapper.between("LIQ_DATE",endDayDate,startDayDate);
			}else {
				queryWrapper.between("LIQ_DATE",startDayDate,endDayDate);
			}


			log.info("测试响应接口1：");
			Map<String, Object> map = dtmExpCardStoreSumService.getMap(queryWrapper);
			log.info("测试响应接口1.2" + map);
			try {
				a = Integer.parseInt(map.get("SUMALL").toString());

			} catch (Exception e) {
				log.info("异常处理逻辑4");
				//a如果获取的是null
				a = -9999;
				return a+"";    //直接返回

			}
			return a+"";
		}else if ( /*str=="VALID_DATA_TAL_CNT"*/TableName=="T_DTM_EXP_FILE_SUM")		//查询文件清算结果统计表T_DTM_EXP_FILE_SUM里面的数据
		{
			QueryWrapper<DtmExpFileSum> queryWrapper = new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data = "sum(" + str + ") as sumAll";
			//数据求和
			queryWrapper.select(/*"sum(TRADE_COUNT) as sumAll"*/data);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE", "268");
			//清算日期是 2021-09-02  获取前一天的时间
			String endDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
			String startDayDate = DateUtils.getDate("yyyy-MM-dd",-24-7*24,Calendar.HOUR_OF_DAY) ;
			log.info("测试响应接口startDayDate："+startDayDate+"   endDayDate:"+endDayDate);
			//比较2个时间的大小
			if (DateUtils.DateCompareSize(startDayDate,endDayDate)>0){
				queryWrapper.between("LIQ_DATE",endDayDate,startDayDate);
			}else {
				queryWrapper.between("LIQ_DATE",startDayDate,endDayDate);
			}

			log.info("测试响应接口13：");
			//SELECT sum(VALID_DATA_TAL_CNT) as sumAll FROM T_DTM_EXP_FILE_SUM WHERE  LIQ_CODE='0001'   AND LIQ_DATE='2021-09-02'
			Map<String, Object> map = dtmExpFileSumService.getMap(queryWrapper);
			log.info("测试响应接口14" + map);
			try {
				a = Integer.parseInt(map.get("SUMALL").toString());

			} catch (Exception e) {
				log.info("异常处理逻辑8");
				//a如果获取的是null
				a = -9999;
				return a+"";    //直接返回
			}
			return a+"";
		}
		return  a+"";
	}

	/**
	 * 临时接口  替代query2的  查询清算一段时间的  就是根据传入时间  查询时间前7天的清算时间范围
	 * 查询指定字段的累计和
	 * 参数1:表里面的指定字段
	 * 参数2: 查询的清算时间
	 *
	 * return:返回指定字段的 指定时间的交易次数累计和
	 *
	 * */
	public  String query5(String data,String date){
		DtmExpDataSum dtmExpDataSum=new DtmExpDataSum();
		if (data!="CARD_COUNT")
		{
			QueryWrapper<DtmExpDataSum> queryWrapper=new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			//数据求和
			String datatemp="sum("+ data /*"TRADE_COUNT"*/  +") as sumAll";
			queryWrapper.select(datatemp);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			//清算日期是 2021-09-02  实际这里是服务器的当天时间
			//TODO
			queryWrapper.eq("LIQ_DATE",date);
//		//交易笔数
//		queryWrapper.eq("tradeCount","2021-09-02");
			log.info("测试响应接口0.1：");
//		dtmExpDataSum=dtmExpDataSumService.getOne(queryWrapper);
			Map<String,Object> map=dtmExpDataSumService.getMap(queryWrapper);
			log.info("测试响应接口2"+map);
			//查询过滤后的值为null   比如查询对比的某个日期的数据 在数据库不存在
			if (map==null)
			{
				log.info("测试响应接口2.1："+map);
				return  -1+"";
			}
			float a=-1;
			try{
				a=	Float.parseFloat(map.get("SUMALL").toString());
			}catch (Exception e){
				log.info("异常处理逻辑5");
				//a如果获取的是null
				a=-9999;
//					e.printStackTrace();
			}
			return  a+"";
		}else 	//因为目前的数据是从2个表出来的 所以要判断一下字段是归类哪个表
		{
			QueryWrapper<DtmExpCardStoreSum> queryWrapper=new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			//数据求和
			String datatemp="sum("+ data /*"TRADE_COUNT"*/  +") as sumAll";
			queryWrapper.select(datatemp);
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			queryWrapper.eq("LIQ_DATE",date);
			log.info("测试响应接口0.2：");
			Map<String,Object> map=dtmExpCardStoreSumService.getMap(queryWrapper);
			log.info("测试响应接口2"+map);
			//查询过滤后的值为null   比如查询对比的某个日期的数据 在数据库不存在
			if (map==null)
			{
				log.info("测试响应接口2.1："+map);
				return  -1+"";
			}
			float a=-1;
			try{
				a=	Float.parseFloat(map.get("SUMALL").toString());
			}catch (Exception e){
				log.info("异常处理逻辑6");
				//a如果获取的是null
				a=-9999;
				return a+"";	//直接返回
			}
			return  a+"";
		}
	}


	/**
	 *综合所有query查询接口暂时除3外
	 *参数1 TableVariable:  查询的表字段
	 *参数2 TableName:查询的表名
	 *参数3 date:查询的时间
	 *参数4 dateend:查询时间范围的结尾时间,只有当参数5 status 为1的时候 该参数才会生效, 默认填写“”
	 *参数5 status:状态值 status=0 表示清算时间字段具体指定。  status=1 表示清算时间是一个范围
	 *
	 * 返回值： 可能整数可能浮点数 所以都string给出
	 *
	 * */
	public String Query(String TableVariable,String TableName,String date,String dateend,int status)
	{
		//总判断是 先判断表 在判断字段 在判断状态  在判断时间
		float a=-1;
		//等价 data!="CARD_COUNT"
		if (TableName=="T_DTM_EXP_DATA_SUM")//消费数据日统计表
		{
			QueryWrapper<DtmExpDataSum> queryWrapper=new QueryWrapper<>();
			//数据求和
			String datatemp="sum("+ TableVariable /*"TRADE_COUNT"*/  +") as sumAll";
			queryWrapper.select(datatemp);
			//服务商 实际应该是查询当前账户对应的服务商
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			//清算日期是 2021-09-02  实际这里是服务器的当天时间
			if (status==0)
			{
				queryWrapper.eq("LIQ_DATE",date);
			}else //status==1
			{
				//比较2个时间的大小
				if (DateUtils.DateCompareSize(date,dateend)>0){
					queryWrapper.between("LIQ_DATE",dateend,date);
				}else {
					queryWrapper.between("LIQ_DATE",date,dateend);
				}
			}
			log.info("Query开始调用sql查询T_DTM_EXP_DATA_SUM表查询字段为"+TableVariable);
			Map<String,Object>	map=dtmExpDataSumService.getMap(queryWrapper);
			//查询过滤后的值为null   比如查询对比的某个日期的数据 在数据库不存在
			if (map==null)
			{
				log.info("Query查询T_DTM_EXP_DATA_SUM表结束 当前Map"+map+"值为Null");
				return  "-1";
			}

			try{
				a=	Float.parseFloat(map.get("SUMALL").toString());
				if (status==0){
					log.info("Query T_DTM_EXP_DATA_SUM表"+"成功获取当前时间:"+date+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
				}else{ //status==1
					log.info("Query T_DTM_EXP_DATA_SUM表"+"成功获取当前时间范围为"+date+"到"+dateend+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
				}
			}catch (Exception e){
				log.info("异常处理逻辑5");
				if (status==0){
					log.info("Query T_DTM_EXP_DATA_SUM表"+"查询失败获取当前时间:"+date+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
				}else{ //status==1
					log.info("Query T_DTM_EXP_DATA_SUM表"+"查询失败获取当前时间"+date+"到"+dateend+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
				}
				//a如果获取的是null
				a=-9999;
				//e.printStackTrace();
			}
			return  a+"";

		}else if (TableName=="T_DTM_EXP_CARD_STORE_SUM")//查询票卡使用商户统计表T_DTM_EXP_CARD_STORE_SUM的数据
		{

			QueryWrapper<DtmExpCardStoreSum> queryWrapper=new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String datatemp="sum("+ TableVariable /*"TRADE_COUNT"*/  +") as sumAll";
			//数据求和
			queryWrapper.select(datatemp);
			//服务商
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE","268");
			//时间
			if (status==0){
				queryWrapper.eq("LIQ_DATE",date);

			}else //status==1
			{
				//比较2个时间的大小
				if (DateUtils.DateCompareSize(date,dateend)>0){
					queryWrapper.between("LIQ_DATE",dateend,date);
				}else {
					queryWrapper.between("LIQ_DATE",date,dateend);
				}

			}
			log.info("Query开始调用sql查询T_DTM_EXP_CARD_STORE_SUM表查询字段为"+TableVariable);
			Map<String,Object> map=dtmExpCardStoreSumService.getMap(queryWrapper);
			//查询过滤后的值为null   比如查询对比的某个日期的数据 在数据库不存在
			if (map==null)
			{
				log.info("Query查询T_DTM_EXP_CARD_STORE_SUM表结束 当前Map"+map+"值为Null");
				return  "-1";
			}
				try{
					a=	Float.parseFloat(map.get("SUMALL").toString());
					if (status==0){
						log.info("Query 查询T_DTM_EXP_CARD_STORE_SUM表"+"成功获取当前时间:"+date+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
					}else{ //status==1
						log.info("Query 查询T_DTM_EXP_CARD_STORE_SUM表"+"成功获取当前时间范围为"+date+"到"+dateend+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
					}
				}catch (Exception e)
				{
					log.info("异常处理逻辑6");
					if (status==0){
						log.info("Query 查询T_DTM_EXP_CARD_STORE_SUM表"+"查询失败获取当前时间:"+date+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
					}else{ //status==1
						log.info("Query 查询T_DTM_EXP_CARD_STORE_SUM表"+"查询失败获取当前时间"+date+"到"+dateend+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
					}
					//a如果获取的是null
					a=-9999;
					return a+"";	//直接返回
				}
			return  a+"";
		}
		else if(TableName=="T_DTM_EXP_FILE_SUM")		//查询文件清算结果统计表T_DTM_EXP_FILE_SUM里面的数据)
		{
			QueryWrapper<DtmExpFileSum> queryWrapper = new QueryWrapper<>();
			//获取指定用户 参数2就是 具体的值  这里先写死一个
			String data = "sum(" + TableVariable + ") as sumAll";
			//数据求和
			queryWrapper.select(data);
			//服务商 是0001的 实际应该是查询当前账户对应的服务商
			queryWrapper.eq(/*"liqCode"*/"LIQ_CODE", "268");
			 if (status==0)  //指定
			 {
//				 String toDayDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
				 queryWrapper.eq("LIQ_DATE",date);
			 }else  //status==1 是范围
			 {
				//清算日期  获取前一天的时间
				 //比较2个时间的大小
				 if (DateUtils.DateCompareSize(date,dateend)>0){
					 queryWrapper.between("LIQ_DATE",dateend,date);
				 }else {
					 queryWrapper.between("LIQ_DATE",date,dateend);
				 }

			 }
			log.info("Query开始调用sql查询T_DTM_EXP_FILE_SUM表查询字段为"+TableVariable);
			//SELECT sum(VALID_DATA_TAL_CNT) as sumAll FROM T_DTM_EXP_FILE_SUM WHERE  LIQ_CODE='0001'   AND LIQ_DATE='2021-09-02'
			Map<String, Object> map = dtmExpFileSumService.getMap(queryWrapper);
			if (map==null)
			{
				log.info("Query查询T_DTM_EXP_FILE_SUM表结束 当前Map"+map+"值为Null");
				return "-1";
			}
			try {
				a = Integer.parseInt(map.get("SUMALL").toString());
				if (status==0){
					log.info("QueryT_DTM_EXP_FILE_SUM表"+"成功获取当前时间:"+date+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
				}else{ //status==1
					log.info("QueryT_DTM_EXP_FILE_SUM表"+"成功获取当前时间范围为"+date+"到"+dateend+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
				}

			} catch (Exception e) {
				log.info("异常处理逻辑8");
				if (status==0){
					log.info("Query T_DTM_EXP_DATA_SUM表"+"查询失败获取当前时间:"+date+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
				}else{ //status==1
					log.info("Query T_DTM_EXP_DATA_SUM表"+"查询失败获取当前时间范围"+date+"到"+dateend+",指定服务商"+"268"+" 表字段"+TableVariable+" 累计和:"+a);
				}
				//a如果获取的是null
				a = -9999;
				return a+"";    //直接返回
			}
			return a+"";

		}

		return 0+"";
	}















	/**
	 * 同比接口
	 * 同比：同比是上一年的比较   比如2021年9月22的数据 就是跟2020年9月22号进行比较
	 * 参数1：比较的表字段
	 * 参数2：表名
	 * 参数3 :0 查询默认同比状态 比如机器前一天和去年同一天比较 清算时间比是一天比一天 。  1 查询清算时间是一个区间的值的同比  清算时间前7天 比前7天
	 * return:返回对应的同比率
	 *
	 * return:返回一个map  第一个是本期数  第二个是同期数  第三个才是同比率
	 * */
	public  Map<String,String>  yearOnYear(String TableVariable,String TableName, int status){
		Map<String,String> retMap=new HashedMap();
		String thisYearDate ="";
		String lastYearDate="";
		String a= "-1";
		String b= "-1";
		if (status==0)
		{
			 thisYearDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
			 lastYearDate= (Integer.parseInt(thisYearDate.substring(0,4))-1)+"-"+thisYearDate.substring(5,7)+"-"+thisYearDate.substring(8,10);
//			 a=  query2(/*"TRADE_COUNT"*/TableVariable,lastYearDate,"",0);
			 a=Query(TableVariable,TableName,lastYearDate,"",0);
//			 b=  query2(/*"TRADE_COUNT"*/TableVariable,thisYearDate,"",0);
			 b=Query(TableVariable,TableName,thisYearDate,"",0);
			log.info("同比a:"+a+" 字段："+TableVariable +"  表名："+TableName+"  时间"+lastYearDate);
			log.info("同比b:"+b+" 字段："+TableVariable +"  表名："+TableName+"  时间"+thisYearDate);

		}else // status=1
		{
			//清算日志条件从准确值变成了范围值
			thisYearDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY);
			String thisYearDateEnd=DateUtils.getDate("yyyy-MM-dd",-24*7,Calendar.HOUR_OF_DAY) ;

			//去年的今天的  这个时间还要减1天才是昨天
			lastYearDate= (Integer.parseInt(thisYearDate.substring(0,4))-1)+"-"+thisYearDate.substring(5,7)+"-"+thisYearDate.substring(8,10);
//			String lastYear= DateUtils.GetDate01(lastYearDate,-1);
			String lastYear2=DateUtils.GetDate01(lastYearDate,-6);
//			a= query2(TableVariable,lastYear,lastYear2,1);
			a=Query(TableVariable,TableName,lastYearDate,lastYear2,1);
//			b=  query2(TableVariable,thisYearDate,thisYearDateEnd,1);
			b=Query(TableVariable,TableName,thisYearDate,thisYearDateEnd,1);

			log.info("同比a:"+a+" 字段："+TableVariable +"  表名："+TableName+"  时间范围"+lastYearDate+" 到 "+lastYear2);
			log.info("同比b:"+b+" 字段："+TableVariable +"  表名："+TableName+"  时间范围"+thisYearDate+" 到 "+thisYearDateEnd);
		}

			//计算同比 同比增长率=（本期数－同期数）÷同期数×100%
			float c= (float)(Float.parseFloat(b)-Float.parseFloat(a))/(Float.parseFloat(a));
			log.info("同比c:"+c);
			java.text.NumberFormat percentFormat =java.text.NumberFormat.getPercentInstance(); percentFormat.setMaximumFractionDigits(2); //最大小数位数
			String  retc= percentFormat.format(c);//自动转换成百分比显示..
			log.info("同比:"+retc);
			if ("REAL_TICKET_PRICE"==TableVariable)			//如果字段是实扣金额
			{
				retMap.put("thisRealTicketPriceSum",String.valueOf(b));	//本期的实扣金额累加和
				retMap.put("lastRealTicketPriceSum",String.valueOf(a)); //同期的实扣金额累加和
				retMap.put("RealTicketPriceYearOnYear",String.valueOf(c));				//实扣金额同比
				return retMap;
			}else if ("TRADE_COUNT"==TableVariable)			//如果字段是交易笔数
			{
				retMap.put("thisTradeCountSum",String.valueOf(b));						//本期的交易笔数累加和
				retMap.put("lastTradeCountSum",String.valueOf(a)); 						//同期的交易笔数累加和
				retMap.put("TradeCountYearOnYear",String.valueOf(c));					//交易笔数同比
				return retMap;
			}else if ("CARD_COUNT"==TableVariable)
			{
				retMap.put("thisCardCountSum",String.valueOf(b));						//本期的票卡数累加和
				retMap.put("lastCardCountSum",String.valueOf(a)); 						//同期票卡数累加和
				retMap.put("CardCountSumYearOnYear",String.valueOf(c));					//票卡数同比
				return retMap;
			}

		//都没匹配上
		return  null;
	}




	/**
	 * 同比接口
	 * 同比：同比是上一年的比较   比如2021年9月22的数据 就是跟2020年9月22号进行比较
	 * 参数1：比较的字段
	 * 参数2: 需要比较的时间段
	 * return:返回对应的同比率
	 *
	 * return:返回一个map  第一个是本期数  第二个是同期数  第三个才是同比率
	 *
	 * return:返回一个map数组  第一个是本期数  第二个是同期数  第三个才是同比率
	 *
	 *
	 *yyyy-MM-dd   0 9     03  56  89
	 * */
	public  Map<String,Map<String,String>>  yearOnYear1(String TableVariable,String TableName,String[] weekDate){
		Map<String,Map<String,String>> localMap=new HashedMap();
		for (int i=0;i<weekDate.length;i++){
			Map<String,String> Objtemp=new HashedMap();
			String thisYearDate =weekDate[i];
			String lastYearDate=(Integer.parseInt(weekDate[i].substring(0,4))-1)+"-"+weekDate[i].substring(5,7)+"-"+weekDate[i].substring(8,10);
//			int a=  	query2(/*"TRADE_COUNT"*/TableVariable,lastYearDate,"",0);
			String a=Query(TableVariable,TableName,lastYearDate,"",0);
//			int b=      query2(/*"TRADE_COUNT"*/TableVariable,thisYearDate,"",0);
			String b=Query(TableVariable,TableName,thisYearDate,"",0);
			float c= (float)(Float.parseFloat(b)-Float.parseFloat(a))/(Float.parseFloat(a));
//			log.info(i+"：同比a:"+a);
			log.info(i+"同比字段："+TableVariable+"  同比字清算时间"+lastYearDate +"同比累计和比较量a："+a);
			log.info(i+"：同比b:"+b);
			log.info(i+"同比字段："+TableVariable+"  同比字清算时间"+thisYearDate +"同比累计和比较量b："+b);
			log.info(i+"同比c:"+c);
			java.text.NumberFormat percentFormat =java.text.NumberFormat.getPercentInstance(); percentFormat.setMaximumFractionDigits(2); //最大小数位数
			String  retc=percentFormat.format(c);//自动转换成百分比显示..     的同比
			log.info("同比百分比："+retc);

			if ("REAL_TICKET_PRICE"==TableVariable)			//如果字段是实扣金额
			{
				if (c>=0){
					Objtemp.put("RealTicketPriceYearTrend","up");		//实扣金额同比状态
				}else{
					Objtemp.put("RealTicketPriceYearTrend","down");	//实扣金额同比状态
				}
				Objtemp.put("RealTicketPriceYearOnYear",retc);				//实扣金额同比   也就是消费金额同比
				localMap.put(weekDate[i],Objtemp);
				log.info(i+"同比字段："+TableVariable+"  同比map:"+localMap);
			}else if ("TRADE_COUNT"==TableVariable)			//如果字段是交易笔数
			{
				if (c>=0){
					Objtemp.put("TradeCountYearTrend","up");			//交易笔数同比状态
				}else{
					Objtemp.put("TradeCountYearTrend","down");			//交易笔数同比状态
				}
				Objtemp.put("TradeCountYearOnYear",retc);	//交易笔数同比  消费笔数同比
				localMap.put(weekDate[i],Objtemp);
				log.info(i+"同比字段："+TableVariable+"  同比map:"+localMap);
			}else if ("CARD_COUNT"==TableVariable)
			{
				Objtemp.put("CardCountSumYearOnYear",String.valueOf(c));					//票卡数同比
				log.info("异常同比");
				log.info(i+"同比字段："+TableVariable+"  同比map:"+localMap);
				//这个接口因为单独拿出来处理 这一个判断逻辑先不管  **
				return null;
			}
		}
		return localMap;
	}

	/**
	 *
	 * 环比接口
	 * 环比：2个周期的变化比  一般来说是拿月为单位, 但是不排除它拿周做比较
	 * 参数1：比较的字段
	 * 参数2：表名
	 * 返回参数1：本期的值
	 * 返回参数2：上一期的值
	 * 返回参数3：环比率
	 * */
	public Map<String,String>  ringRatio(String data,String TableName){
		Map<String,String> retMap=new HashedMap();
		//拿到currentCycleDate 的年和月
		//判断月如果不是1月
		//那么lastCycleDate 的月份就是 拿到currentCycleDate的月份 -1
		String currentCycleDate = DateUtils.getDate("yyyy-MM-dd",-24,Calendar.HOUR_OF_DAY) ;
		String lastCycleDate="";
		if ((Integer.parseInt(currentCycleDate.substring(5,7)))!=1)	//1月的时候直接减 比如时间2022-01-01  就会变成2022-0-01了  出现BUG
		{
			lastCycleDate= currentCycleDate.substring(0,4)+"-"+(Integer.parseInt(currentCycleDate.substring(5,7))-1)+"-"+currentCycleDate.substring(8,10);
		}else  //月份为1月
		{
			//1月的时候直接减 比如时间2022-01-01  其实要比的是2021-12-01
//			lastCycleDate=	(Integer.parseInt(currentCycleDate.substring(0,4))-1)+"-"+"12"+"-"+currentCycleDate.substring(8,10);
			lastCycleDate=	(Integer.parseInt(DateUtils.getYear())-1)+"-"+"12"+"-"+DateUtils.getDay();
		}
		//环比是一个月 就是月头到月尾
		//获取当前日期前一天的字符串并转成Date类型
		Date date=  DateUtils.parseDate(lastCycleDate.substring(0,7));
		//获取查询月份有多少天  环比数据查询sql的时候需要
		int monthEnd= DateUtils.getMonthHasDays(date);
		//知道了月和 月有多少天 开始拼接月头和月尾
		String lastCycleDateMonthStart= lastCycleDate.substring(0,7)+"-"+"01";
		String lastCycleDateMonthEnd= lastCycleDate.substring(0,7)+"-"+monthEnd;
		String a=Query(data,TableName,lastCycleDateMonthStart,lastCycleDateMonthEnd,1);

		Date date1=  DateUtils.parseDate(currentCycleDate.substring(0,7));
		int monthEnd1= DateUtils.getMonthHasDays(date1);
		String currentCycleDateMonthStart= currentCycleDate.substring(0,7)+"-"+"01";
		String currentCycleDateMonthEnd= currentCycleDate.substring(0,7)+"-"+monthEnd1;
		String b=Query(data,TableName,currentCycleDateMonthStart,currentCycleDateMonthEnd,1);

		//计算环比  环比增长率=（本期的某个指标的值-上一期这个指标的值）/上一期这个指标的值*100%
		float c= (float)(Float.parseFloat(b)-Float.parseFloat(a))/(Float.parseFloat(a));
		log.info("环比a:"+a+ " 字段："+data +"  表名："+TableName+"  时间范围"+lastCycleDateMonthStart+" 到 "+lastCycleDateMonthEnd);
		log.info("环比b:"+b+ " 字段："+data +"  表名："+TableName+"  时间范围"+currentCycleDateMonthStart+" 到 "+currentCycleDateMonthEnd);
		log.info("环比c:"+c);
		java.text.NumberFormat percentFormat =java.text.NumberFormat.getPercentInstance(); percentFormat.setMaximumFractionDigits(2); //最大小数位数
		String  ret= percentFormat.format(c);//自动转换成百分比显示..
		log.info("环比:"+ret);

		if ("REAL_TICKET_PRICE"==data)			//如果字段是实扣金额
		{
			retMap.put("thisRealTicketPriceSum",String.valueOf(b));	//本期的实扣金额累加和
			retMap.put("lastRealTicketPriceSum2",String.valueOf(a)); //上一期的实扣金额累加和
			retMap.put("RealTicketPriceRingRatio",String.valueOf(c));//实扣金额环比
			return retMap;
		}else if ("TRADE_COUNT"==data)			//如果字段是交易笔数

		{
			retMap.put("thisTradeCountSum",String.valueOf(b));						//本期的交易笔数累加和
			retMap.put("lastTradeCountSum2",String.valueOf(a)); 						//上一期的交易笔数累加和
			retMap.put("TradeCountRingRatio",String.valueOf(c));					//交易笔数环比
			return retMap;
		}else if ("CARD_COUNT"==data){
			retMap.put("thisCardCountSum",String.valueOf(b));						//本期的票卡数累加和
			retMap.put("lastCardCountSum2",String.valueOf(a)); 						//上一期票卡数累加值
			retMap.put("CardCountRingRatio",String.valueOf(c));					//票卡数环比
			return retMap;
		}
		return  null;
	}



	/**
	 *
	 * 环比接口
	 * 环比：2个周期的变化比  一般来说是拿月为单位, 但是不排除它拿周做比较
	 * 参数1：比较的字段
	 * 参数2：比较的时间段
	 *
	 * return:返回一个map数组
	 *
	 *
	 * */
	public Map<String,Map<String,String>>  ringRatio1(String TableVariable,String TableName, String[] weekDate){
		Map<String,Map<String,String>>localMap=new HashedMap();
		for (int i=0;i<weekDate.length;i++)
		{
			Map<String,String>ringRatio1objtemp=new HashedMap();
			String currentCycleDate =weekDate[i];
			String lastCycleDate=(Integer.parseInt(weekDate[i].substring(0,4))-1)+"-"+weekDate[i].substring(5,7)+"-"+weekDate[i].substring(8,10);
//			int a=  	query2(/*"TRADE_COUNT"*/TableVariable,lastCycleDate,"",0);
			String a=Query(TableVariable,TableName,lastCycleDate,"",0);
//			int b=      query2(/*"TRADE_COUNT"*/TableVariable,currentCycleDate,"",0);
			String b=      Query(/*"TRADE_COUNT"*/TableVariable,TableName,lastCycleDate,"",0);
			//计算环比  环比增长率=（本期的某个指标的值-上一期这个指标的值）/上一期这个指标的值*100%
			float c= (float)(Float.parseFloat(b)-Float.parseFloat(a))/(Float.parseFloat(a));
			log.info(i+"环比字段："+TableVariable+"  环比清算时间"+weekDate[i] +"环比累计和比较量a："+a);
			log.info(i+"环比字段："+TableVariable+"  环比清算时间"+weekDate[i] +"环比累计和比较量b："+b);
			log.info(i+"：环比c:"+c);
			java.text.NumberFormat percentFormat =java.text.NumberFormat.getPercentInstance(); percentFormat.setMaximumFractionDigits(2); //最大小数位数
			String  ret= percentFormat.format(c);//自动转换成百分比显示..
			log.info("环比百分:"+ret);

			if ("REAL_TICKET_PRICE"==TableVariable)			//如果字段是实扣金额
			{
				if (c>=0){
					ringRatio1objtemp.put("RealTicketPriceMonthContrastTrend","up");//实扣金额环比状态
				}else{
					ringRatio1objtemp.put("RealTicketPriceMonthContrastTrend","down");//实扣金额环比状态
				}
				ringRatio1objtemp.put("RealTicketPriceRingRatio",ret);//实扣金额环比
				localMap.put(weekDate[i],ringRatio1objtemp);
				log.info(i+"环比字段："+TableVariable+"  环比map:"+localMap);
			}else if ("TRADE_COUNT"==TableVariable)			//如果字段是交易笔数
			{
				if (c>=0){
					ringRatio1objtemp.put("TradeCountMonthContrastTrend","up");	//交易笔数环比状态
				}else{
					ringRatio1objtemp.put("TradeCountMonthContrastTrend","down");//交易笔数环比状态
				}
				ringRatio1objtemp.put("TradeCountRingRatio",ret);
				localMap.put(weekDate[i],ringRatio1objtemp);
				log.info(i+"环比字段："+TableVariable+"  环比map:"+localMap);

			}else if ("CARD_COUNT"==TableVariable){
				log.info("异常环比");
				ringRatio1objtemp.put("CardCountRingRatio",String.valueOf(c));					//票卡数环比
				//这里就不该进来
				return null;
			}
		}
		return  localMap;
	}



	/**
	 *
	 * 传入2个 map,当key相同的时候,value会进行合并
	 * 例子 map1  {a={1,2}}
	 *     map2  {a={4，5}}
	 *
	 *    map合 {a={1,2,4,5}}
	 *
	 *  参数1:被合并的map1
	 *  参数2:被合并的map2
	 *
	 */
	public Map<String,Map<String,String>>  MapValueAdd(Map<String,Map<String,String>> map1,Map<String,Map<String,String>> map2){
		Map<String,Map<String,String>> temp1=new HashedMap();
		//第二种   终于搞定了  这个看起来可以封一个函数
		for (Map.Entry<String, Map<String, String>> out : map1.entrySet())
		{
			Map<String,String> temp2=new HashedMap();
			log.info("重点检查2key："+out.getKey()   +" value："+out.getValue());
			////时间相同
			if (map2.containsKey(out.getKey())){
				//把他们2个的value  都先取出来 存到一个新的mqp里面
				//先取1的 value 里面的 key和 value 放到新的map里面
				for (Map.Entry<String, String> nameMapEntry : (out.getValue()).entrySet()){
					String numKey = nameMapEntry.getKey();
					String nameValue = nameMapEntry.getValue();
					//把1 value  map里面的key  value放到新的map里面
					temp2.put(numKey,nameValue);
					log.info("MapValueAdd开始取map1里面的元素 map1里面的key:"+numKey+"  map1里面的value:"+nameValue);
					log.info("MapValueAdd目前的temp:"+ temp2);
				}
				//再取2的value 里面的 key和 value 放到新的map里面
				for (Map.Entry<String, String> nameMapEntry2 : map2.get(out.getKey()).entrySet()){
					String numKey2 = nameMapEntry2.getKey();
					String nameValue2 = nameMapEntry2.getValue();
					//把2 value  map里面的key  value放到新的map里面
					temp2.put(numKey2,nameValue2);
					log.info("MapValueAdd开始取map2里面的元素 map2里面的key:"+numKey2+"  map2里面的value:"+nameValue2);
					log.info("MapValueAdd目前的temp:"+ temp2);
				}
				log.info("MapValueAdd开始拼装, key:"+out.getKey()+ "  value："+ temp2);
				//拿2map重新装
				map2.put(out.getKey(), temp2);
				log.info("MapValueAdd拼装完成 当前："+map2);
			}
			log.info("MapValueAdd拼装完成 当前2："+map2);
		}
		log.info("看看2："+map2);
		return  map2;

//		//第二种   终于搞定了  这个看起来可以封一个函数
//		for (Map.Entry<String, Map<String, String>> out : localretMap1.entrySet())
//		{
//			log.info("重点检查2key："+out.getKey()   +" value："+out.getValue());
//
//			////时间相同
//			if (localretMap2.containsKey(out.getKey())){
//				//把他们2个的value  都先取出来 存到一个新的mqp里面
//				//先取1的 value 里面的 key和 value 放到新的map里面
//				for (Map.Entry<String, String> nameMapEntry : (out.getValue()).entrySet()){
//					String numKey = nameMapEntry.getKey();
//					String nameValue = nameMapEntry.getValue();
//					//把1 value  map里面的key  value放到新的map里面
//					Obj1.put(numKey,nameValue);
//				}
//				//再取2的value 里面的 key和 value 放到新的map里面
//				for (Map.Entry<String, String> nameMapEntry2 : localretMap2.get(out.getKey()).entrySet()){
//					String numKey2 = nameMapEntry2.getKey();
//					String nameValue2 = nameMapEntry2.getValue();
//					//把2 value  map里面的key  value放到新的map里面
//					Obj1.put(numKey2,nameValue2);
//				}
//				//拿2map重新装
//				localretMap2.put(out.getKey(), Obj1);
//				log.info("看看："+localretMap2);
//			}
//		}
//		log.info("看看2："+localretMap2);
//
	}





//	public static void main(String[] args) {
////		Test();
//	}

}
